home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / info / gnus.info-7.z / gnus.info-7
Encoding:
GNU Info File  |  1998-05-21  |  49.2 KB  |  1,271 lines
  1. This is Info file ../info/gnus.info, produced by Makeinfo version 1.68
  2. from the input file gnus.texi.
  3.  
  4.    This file documents Gnus, the GNU Emacs newsreader.
  5.  
  6.    Copyright (C) 1995,96 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the entire resulting derived work is distributed under the terms
  15. of a permission notice identical to this one.
  16.  
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions.
  20.  
  21. 
  22. File: gnus.info,  Node: SOUP Groups,  Next: SOUP Replies,  Prev: SOUP Commands,  Up: SOUP
  23.  
  24. SOUP Groups
  25. ...........
  26.  
  27.    `nnsoup' is the backend for reading SOUP packets.  It will read
  28. incoming packets, unpack them, and put them in a directory where you
  29. can read them at leisure.
  30.  
  31.    These are the variables you can use to customize its behavior:
  32.  
  33. `nnsoup-tmp-directory'
  34.      When `nnsoup' unpacks a SOUP packet, it does it in this directory.
  35.      (`/tmp/' by default.)
  36.  
  37. `nnsoup-directory'
  38.      `nnsoup' then moves each message and index file to this directory.
  39.      The default is `~/SOUP/'.
  40.  
  41. `nnsoup-replies-directory'
  42.      All replies will be stored in this directory before being packed
  43.      into a reply packet.  The default is `~/SOUP/replies/"'.
  44.  
  45. `nnsoup-replies-format-type'
  46.      The SOUP format of the replies packets.  The default is `?n'
  47.      (rnews), and I don't think you should touch that variable.  I
  48.      probably shouldn't even have documented it.  Drats!  Too late!
  49.  
  50. `nnsoup-replies-index-type'
  51.      The index type of the replies packet.  The default is `?n', which
  52.      means "none".  Don't fiddle with this one either!
  53.  
  54. `nnsoup-active-file'
  55.      Where `nnsoup' stores lots of information.  This is not an "active
  56.      file" in the `nntp' sense; it's an Emacs Lisp file.  If you lose
  57.      this file or mess it up in any way, you're dead.  The default is
  58.      `~/SOUP/active'.
  59.  
  60. `nnsoup-packer'
  61.      Format string command for packing a reply SOUP packet.  The default
  62.      is `tar cf - %s | gzip > $HOME/Soupin%d.tgz'.
  63.  
  64. `nnsoup-unpacker'
  65.      Format string command for unpacking incoming SOUP packets.  The
  66.      default is `gunzip -c %s | tar xvf -'.
  67.  
  68. `nnsoup-packet-directory'
  69.      Where `nnsoup' will look for incoming packets.  The default is
  70.      `~/'.
  71.  
  72. `nnsoup-packet-regexp'
  73.      Regular expression matching incoming SOUP packets.  The default is
  74.      `Soupout'.
  75.  
  76. 
  77. File: gnus.info,  Node: SOUP Replies,  Prev: SOUP Groups,  Up: SOUP
  78.  
  79. SOUP Replies
  80. ............
  81.  
  82.    Just using `nnsoup' won't mean that your postings and mailings end
  83. up in SOUP reply packets automagically.  You have to work a bit more
  84. for that to happen.
  85.  
  86.    The `nnsoup-set-variables' command will set the appropriate
  87. variables to ensure that all your followups and replies end up in the
  88. SOUP system.
  89.  
  90.    In specific, this is what it does:
  91.  
  92.      (setq message-send-news-function 'nnsoup-request-post)
  93.      (setq message-send-mail-function 'nnsoup-request-mail)
  94.  
  95.    And that's it, really.  If you only want news to go into the SOUP
  96. system you just use the first line.  If you only want mail to be SOUPed
  97. you use the second.
  98.  
  99. 
  100. File: gnus.info,  Node: Web Searches,  Next: Mail-To-News Gateways,  Prev: SOUP,  Up: Other Sources
  101.  
  102. Web Searches
  103. ------------
  104.  
  105.    It's, like, too neat to search the Usenet for articles that match a
  106. string, but it, like, totally *sucks*, like, totally, to use one of
  107. those, like, Web browsers, and you, like, have to, rilly, like, look at
  108. the commercials, so, like, with Gnus you can do *rad*, rilly, searches
  109. without having to use a browser.
  110.  
  111.    The `nnweb' backend allows an easy interface to the mighty search
  112. engine.  You create an `nnweb' group, enter a search pattern, and then
  113. enter the group and read the articles like you would any normal group.
  114. The `G w' command in the group buffer (*note Foreign Groups::.) will do
  115. this in an easy-to-use fashion.
  116.  
  117.    `nnweb' groups don't really lend themselves to being solid
  118. groups--they have a very fleeting idea of article numbers.  In fact,
  119. each time you enter an `nnweb' group (not even changing the search
  120. pattern), you are likely to get the articles ordered in a different
  121. manner.  Not even using duplicate suppression (*note Duplicate
  122. Suppression::.) will help, since `nnweb' doesn't even know the
  123. `Message-ID' of the articles before reading them using some search
  124. engines (DejaNews, for instance).  The only possible way to keep track
  125. of which articles you've read is by scoring on the `Date' header--mark
  126. all articles posted before the last date you read the group as read.
  127.  
  128.    If the search engine changes its output substantially, `nnweb' won't
  129. be able to parse it and will fail.  One could hardly fault the Web
  130. providers if they were to do this--their *raison d'Ωtre* is to make
  131. money off of advertisements, not to provide services to the community.
  132. Since `nnweb' washes the ads off all the articles, one might think that
  133. the providers might be somewhat miffed.  We'll see.
  134.  
  135.    You must have the `url' and `w3' package installed to be able to use
  136. `nnweb'.
  137.  
  138.    Virtual server variables:
  139.  
  140. `nnweb-type'
  141.      What search engine type is being used.  The currently supported
  142.      types are `dejanews', `altavista' and `reference'.
  143.  
  144. `nnweb-search'
  145.      The search string to feed to the search engine.
  146.  
  147. `nnweb-max-hits'
  148.      Advisory maximum number of hits per search to display.  The
  149.      default is 100.
  150.  
  151. `nnweb-type-definition'
  152.      Type-to-definition alist.  This alist says what `nnweb' should do
  153.      with the various search engine types.  The following elements must
  154.      be present:
  155.  
  156.     `article'
  157.           Function to decode the article and provide something that Gnus
  158.           understands.
  159.  
  160.     `map'
  161.           Function to create an article number to message header and
  162.           URL alist.
  163.  
  164.     `search'
  165.           Function to send the search string to the search engine.
  166.  
  167.     `address'
  168.           The address the aforementioned function should send the
  169.           search string to.
  170.  
  171.     `id'
  172.           Format string URL to fetch an article by `Message-ID'.
  173.  
  174. 
  175. File: gnus.info,  Node: Mail-To-News Gateways,  Prev: Web Searches,  Up: Other Sources
  176.  
  177. Mail-To-News Gateways
  178. ---------------------
  179.  
  180.    If your local `nntp' server doesn't allow posting, for some reason
  181. or other, you can post using one of the numerous mail-to-news gateways.
  182. The `nngateway' backend provides the interface.
  183.  
  184.    Note that you can't read anything from this backend--it can only be
  185. used to post with.
  186.  
  187.    Server variables:
  188.  
  189. `nngateway-address'
  190.      This is the address of the mail-to-news gateway.
  191.  
  192. `nngateway-header-transformation'
  193.      News headers often have to be transformed in some odd way or other
  194.      for the mail-to-news gateway to accept it.  This variable says what
  195.      transformation should be called, and defaults to
  196.      `nngateway-simple-header-transformation'.  The function is called
  197.      narrowed to the headers to be transformed and with one
  198.      parameter--the gateway address.
  199.  
  200.      This default function just inserts a new `To' header based on the
  201.      `Newsgroups' header and the gateway address.  For instance, an
  202.      article with this `Newsgroups' header:
  203.  
  204.           Newsgroups: alt.religion.emacs
  205.  
  206.      will get this `From' header inserted:
  207.  
  208.           To: alt-religion-emacs@GATEWAY
  209.  
  210.    So, to use this, simply say something like:
  211.  
  212.      (setq gnus-post-method '(nngateway "GATEWAY.ADDRESS"))
  213.  
  214. 
  215. File: gnus.info,  Node: Combined Groups,  Prev: Other Sources,  Up: Select Methods
  216.  
  217. Combined Groups
  218. ===============
  219.  
  220.    Gnus allows combining a mixture of all the other group types into
  221. bigger groups.
  222.  
  223. * Menu:
  224.  
  225. * Virtual Groups::     Combining articles from many groups.
  226. * Kibozed Groups::     Looking through parts of the newsfeed for articles.
  227.  
  228. 
  229. File: gnus.info,  Node: Virtual Groups,  Next: Kibozed Groups,  Up: Combined Groups
  230.  
  231. Virtual Groups
  232. --------------
  233.  
  234.    An "nnvirtual group" is really nothing more than a collection of
  235. other groups.
  236.  
  237.    For instance, if you are tired of reading many small groups, you can
  238. put them all in one big group, and then grow tired of reading one big,
  239. unwieldy group.  The joys of computing!
  240.  
  241.    You specify `nnvirtual' as the method.  The address should be a
  242. regexp to match component groups.
  243.  
  244.    All marks in the virtual group will stick to the articles in the
  245. component groups.  So if you tick an article in a virtual group, the
  246. article will also be ticked in the component group from whence it came.
  247. (And vice versa--marks from the component groups will also be shown in
  248. the virtual group.)
  249.  
  250.    Here's an example `nnvirtual' method that collects all Andrea Dworkin
  251. newsgroups into one, big, happy newsgroup:
  252.  
  253.      (nnvirtual "^alt\\.fan\\.andrea-dworkin$\\|^rec\\.dworkin.*")
  254.  
  255.    The component groups can be native or foreign; everything should work
  256. smoothly, but if your computer explodes, it was probably my fault.
  257.  
  258.    Collecting the same group from several servers might actually be a
  259. good idea if users have set the Distribution header to limit
  260. distribution.  If you would like to read `soc.motss' both from a server
  261. in Japan and a server in Norway, you could use the following as the
  262. group regexp:
  263.  
  264.      "^nntp+some.server.jp:soc.motss$\\|^nntp+some.server.no:soc.motss$"
  265.  
  266.    This should work kinda smoothly--all articles from both groups should
  267. end up in this one, and there should be no duplicates.  Threading (and
  268. the rest) will still work as usual, but there might be problems with the
  269. sequence of articles.  Sorting on date might be an option here (*note
  270. Selecting a Group::.).
  271.  
  272.    One limitation, however--all groups included in a virtual group have
  273. to be alive (i.e., subscribed or unsubscribed).  Killed or zombie
  274. groups can't be component groups for `nnvirtual' groups.
  275.  
  276.    If the `nnvirtual-always-rescan' is non-`nil', `nnvirtual' will
  277. always scan groups for unread articles when entering a virtual group.
  278. If this variable is `nil' (which is the default) and you read articles
  279. in a component group after the virtual group has been activated, the
  280. read articles from the component group will show up when you enter the
  281. virtual group.  You'll also see this effect if you have two virtual
  282. groups that have a component group in common.  If that's the case, you
  283. should set this variable to `t'.  Or you can just tap `M-g' on the
  284. virtual group every time before you enter it--it'll have much the same
  285. effect.
  286.  
  287. 
  288. File: gnus.info,  Node: Kibozed Groups,  Prev: Virtual Groups,  Up: Combined Groups
  289.  
  290. Kibozed Groups
  291. --------------
  292.  
  293.    "Kibozing" is defined by OED as "grepping through (parts of) the
  294. news feed".  `nnkiboze' is a backend that will do this for you.  Oh
  295. joy!  Now you can grind any NNTP server down to a halt with useless
  296. requests!  Oh happiness!
  297.  
  298.    To create a kibozed group, use the `G k' command in the group buffer.
  299.  
  300.    The address field of the `nnkiboze' method is, as with `nnvirtual',
  301. a regexp to match groups to be "included" in the `nnkiboze' group.
  302. That's where most similarities between `nnkiboze' and `nnvirtual' end.
  303.  
  304.    In addition to this regexp detailing component groups, an `nnkiboze'
  305. group must have a score file to say what articles are to be included in
  306. the group (*note Scoring::.).
  307.  
  308.    You must run `M-x nnkiboze-generate-groups' after creating the
  309. `nnkiboze' groups you want to have.  This command will take time.  Lots
  310. of time.  Oodles and oodles of time.  Gnus has to fetch the headers from
  311. all the articles in all the component groups and run them through the
  312. scoring process to determine if there are any articles in the groups
  313. that are to be part of the `nnkiboze' groups.
  314.  
  315.    Please limit the number of component groups by using restrictive
  316. regexps.  Otherwise your sysadmin may become annoyed with you, and the
  317. NNTP site may throw you off and never let you back in again.  Stranger
  318. things have happened.
  319.  
  320.    `nnkiboze' component groups do not have to be alive--they can be
  321. dead, and they can be foreign.  No restrictions.
  322.  
  323.    The generation of an `nnkiboze' group means writing two files in
  324. `nnkiboze-directory', which is `~/News/' by default.  One contains the
  325. NOV header lines for all the articles in the group, and the other is an
  326. additional `.newsrc' file to store information on what groups have been
  327. searched through to find component articles.
  328.  
  329.    Articles marked as read in the `nnkiboze' group will have their NOV
  330. lines removed from the NOV file.
  331.  
  332. 
  333. File: gnus.info,  Node: Scoring,  Next: Various,  Prev: Select Methods,  Up: Top
  334.  
  335. Scoring
  336. *******
  337.  
  338.    Other people use "kill files", but we here at Gnus Towers like
  339. scoring better than killing, so we'd rather switch than fight.  They do
  340. something completely different as well, so sit up straight and pay
  341. attention!
  342.  
  343.    All articles have a default score (`gnus-summary-default-score'),
  344. which is 0 by default.  This score may be raised or lowered either
  345. interactively or by score files.  Articles that have a score lower than
  346. `gnus-summary-mark-below' are marked as read.
  347.  
  348.    Gnus will read any "score files" that apply to the current group
  349. before generating the summary buffer.
  350.  
  351.    There are several commands in the summary buffer that insert score
  352. entries based on the current article.  You can, for instance, ask Gnus
  353. to lower or increase the score of all articles with a certain subject.
  354.  
  355.    There are two sorts of scoring entries: Permanent and temporary.
  356. Temporary score entries are self-expiring entries.  Any entries that are
  357. temporary and have not been used for, say, a week, will be removed
  358. silently to help keep the sizes of the score files down.
  359.  
  360. * Menu:
  361.  
  362. * Summary Score Commands::   Adding score entries for the current group.
  363. * Group Score Commands::     General score commands.
  364. * Score Variables::          Customize your scoring.  (My, what terminology).
  365. * Score File Format::        What a score file may contain.
  366. * Score File Editing::       You can edit score files by hand as well.
  367. * Adaptive Scoring::         Big Sister Gnus knows what you read.
  368. * Home Score File::          How to say where new score entries are to go.
  369. * Followups To Yourself::    Having Gnus notice when people answer you.
  370. * Scoring Tips::             How to score effectively.
  371. * Reverse Scoring::          That problem child of old is not problem.
  372. * Global Score Files::       Earth-spanning, ear-splitting score files.
  373. * Kill Files::               They are still here, but they can be ignored.
  374. * Converting Kill Files::    Translating kill files to score files.
  375. * GroupLens::                Getting predictions on what you like to read.
  376. * Advanced Scoring::         Using logical expressions to build score rules.
  377. * Score Decays::             It can be useful to let scores wither away.
  378.  
  379. 
  380. File: gnus.info,  Node: Summary Score Commands,  Next: Group Score Commands,  Up: Scoring
  381.  
  382. Summary Score Commands
  383. ======================
  384.  
  385.    The score commands that alter score entries do not actually modify
  386. real score files.  That would be too inefficient.  Gnus maintains a
  387. cache of previously loaded score files, one of which is considered the
  388. "current score file alist".  The score commands simply insert entries
  389. into this list, and upon group exit, this list is saved.
  390.  
  391.    The current score file is by default the group's local score file,
  392. even if no such score file actually exists.  To insert score commands
  393. into some other score file (e.g. `all.SCORE'), you must first make this
  394. score file the current one.
  395.  
  396.    General score commands that don't actually change the score file:
  397.  
  398. `V s'
  399.      Set the score of the current article (`gnus-summary-set-score').
  400.  
  401. `V S'
  402.      Display the score of the current article
  403.      (`gnus-summary-current-score').
  404.  
  405. `V t'
  406.      Display all score rules that have been used on the current article
  407.      (`gnus-score-find-trace').
  408.  
  409. `V R'
  410.      Run the current summary through the scoring process
  411.      (`gnus-summary-rescore').  This might be useful if you're playing
  412.      around with your score files behind Gnus' back and want to see the
  413.      effect you're having.
  414.  
  415. `V a'
  416.      Add a new score entry, and allow specifying all elements
  417.      (`gnus-summary-score-entry').
  418.  
  419. `V c'
  420.      Make a different score file the current
  421.      (`gnus-score-change-score-file').
  422.  
  423. `V e'
  424.      Edit the current score file (`gnus-score-edit-current-scores').
  425.      You will be popped into a `gnus-score-mode' buffer (*note Score
  426.      File Editing::.).
  427.  
  428. `V f'
  429.      Edit a score file and make this score file the current one
  430.      (`gnus-score-edit-file').
  431.  
  432. `V F'
  433.      Flush the score cache (`gnus-score-flush-cache').  This is useful
  434.      after editing score files.
  435.  
  436. `V C'
  437.      Customize a score file in a visually pleasing manner
  438.      (`gnus-score-customize').
  439.  
  440.    The rest of these commands modify the local score file.
  441.  
  442. `V m'
  443.      Prompt for a score, and mark all articles with a score below this
  444.      as read (`gnus-score-set-mark-below').
  445.  
  446. `V x'
  447.      Prompt for a score, and add a score rule to the current score file
  448.      to expunge all articles below this score
  449.      (`gnus-score-set-expunge-below').
  450.  
  451.    The keystrokes for actually making score entries follow a very
  452. regular pattern, so there's no need to list all the commands.
  453. (Hundreds of them.)
  454.  
  455.   1. The first key is either `I' (upper case i) for increasing the score
  456.      or `L' for lowering the score.
  457.  
  458.   2. The second key says what header you want to score on.  The
  459.      following keys are available:
  460.     `a'
  461.           Score on the author name.
  462.  
  463.     `s'
  464.           Score on the subject line.
  465.  
  466.     `x'
  467.           Score on the Xref line--i.e., the cross-posting line.
  468.  
  469.     `t'
  470.           Score on thread--the References line.
  471.  
  472.     `d'
  473.           Score on the date.
  474.  
  475.     `l'
  476.           Score on the number of lines.
  477.  
  478.     `i'
  479.           Score on the Message-ID.
  480.  
  481.     `f'
  482.           Score on followups.
  483.  
  484.     `b'
  485.           Score on the body.
  486.  
  487.     `h'
  488.           Score on the head.
  489.  
  490.   3. The third key is the match type.  Which match types are legal
  491.      depends on what headers you are scoring on.
  492.  
  493.     `strings'
  494.  
  495.          `e'
  496.                Exact matching.
  497.  
  498.          `s'
  499.                Substring matching.
  500.  
  501.          `f'
  502.                Fuzzy matching (*note Fuzzy Matching::.).
  503.  
  504.          `r'
  505.                Regexp matching
  506.  
  507.     `date'
  508.  
  509.          `b'
  510.                Before date.
  511.  
  512.          `a'
  513.                At date.
  514.  
  515.          `n'
  516.                This date.
  517.  
  518.     `number'
  519.  
  520.          `<'
  521.                Less than number.
  522.  
  523.          `='
  524.                Equal to number.
  525.  
  526.          `>'
  527.                Greater than number.
  528.  
  529.   4. The fourth and final key says whether this is a temporary (i.e.,
  530.      expiring) score entry, or a permanent (i.e., non-expiring) score
  531.      entry, or whether it is to be done immediately, without adding to
  532.      the score file.
  533.     `t'
  534.           Temporary score entry.
  535.  
  536.     `p'
  537.           Permanent score entry.
  538.  
  539.     `i'
  540.           Immediately scoring.
  541.  
  542.  
  543.    So, let's say you want to increase the score on the current author
  544. with exact matching permanently: `I a e p'.  If you want to lower the
  545. score based on the subject line, using substring matching, and make a
  546. temporary score entry: `L s s t'.  Pretty easy.
  547.  
  548.    To make things a bit more complicated, there are shortcuts.  If you
  549. use a capital letter on either the second or third keys, Gnus will use
  550. defaults for the remaining one or two keystrokes.  The defaults are
  551. "substring" and "temporary".  So `I A' is the same as `I a s t', and `I
  552. a R' is the same as `I a r t'.
  553.  
  554.    The `gnus-score-mimic-keymap' says whether these commands will
  555. pretend they are keymaps or not.
  556.  
  557. 
  558. File: gnus.info,  Node: Group Score Commands,  Next: Score Variables,  Prev: Summary Score Commands,  Up: Scoring
  559.  
  560. Group Score Commands
  561. ====================
  562.  
  563.    There aren't many of these as yet, I'm afraid.
  564.  
  565. `W f'
  566.      Gnus maintains a cache of score alists to avoid having to reload
  567.      them all the time.  This command will flush the cache
  568.      (`gnus-score-flush-cache').
  569.  
  570. 
  571. File: gnus.info,  Node: Score Variables,  Next: Score File Format,  Prev: Group Score Commands,  Up: Scoring
  572.  
  573. Score Variables
  574. ===============
  575.  
  576. `gnus-use-scoring'
  577.      If `nil', Gnus will not check for score files, and will not, in
  578.      general, do any score-related work.  This is `t' by default.
  579.  
  580. `gnus-kill-killed'
  581.      If this variable is `nil', Gnus will never apply score files to
  582.      articles that have already been through the kill process.  While
  583.      this may save you lots of time, it also means that if you apply a
  584.      kill file to a group, and then change the kill file and want to
  585.      run it over you group again to kill more articles, it won't work.
  586.      You have to set this variable to `t' to do that.  (It is `t' by
  587.      default.)
  588.  
  589. `gnus-kill-files-directory'
  590.      All kill and score files will be stored in this directory, which is
  591.      initialized from the `SAVEDIR' environment variable by default.
  592.      This is `~/News/' by default.
  593.  
  594. `gnus-score-file-suffix'
  595.      Suffix to add to the group name to arrive at the score file name
  596.      (`SCORE' by default.)
  597.  
  598. `gnus-score-uncacheable-files'
  599.      All score files are normally cached to avoid excessive re-loading
  600.      of score files.  However, if this might make you Emacs grow big and
  601.      bloated, so this regexp can be used to weed out score files
  602.      unlikely to be needed again.  It would be a bad idea to deny
  603.      caching of `all.SCORE', while it might be a good idea to not cache
  604.      `comp.infosystems.www.authoring.misc.ADAPT'.  In fact, this
  605.      variable is `ADAPT$' by default, so no adaptive score files will
  606.      be cached.
  607.  
  608. `gnus-save-score'
  609.      If you have really complicated score files, and do lots of batch
  610.      scoring, then you might set this variable to `t'.  This will make
  611.      Gnus save the scores into the `.newsrc.eld' file.
  612.  
  613. `gnus-score-interactive-default-score'
  614.      Score used by all the interactive raise/lower commands to
  615.      raise/lower score with.  Default is 1000, which may seem
  616.      excessive, but this is to ensure that the adaptive scoring scheme
  617.      gets enough room to play with.  We don't want the small changes
  618.      from the adaptive scoring to overwrite manually entered data.
  619.  
  620. `gnus-summary-default-score'
  621.      Default score of an article, which is 0 by default.
  622.  
  623. `gnus-summary-expunge-below'
  624.      Don't display the summary lines of articles that have scores lower
  625.      than this variable.  This is `nil' by default, which means that no
  626.      articles will be hidden.
  627.  
  628. `gnus-score-over-mark'
  629.      Mark (in the third column) used for articles with a score over the
  630.      default.  Default is `+'.
  631.  
  632. `gnus-score-below-mark'
  633.      Mark (in the third column) used for articles with a score below the
  634.      default.  Default is `-'.
  635.  
  636. `gnus-score-find-score-files-function'
  637.      Function used to find score files for the current group.  This
  638.      function is called with the name of the group as the argument.
  639.  
  640.      Predefined functions available are:
  641.     `gnus-score-find-single'
  642.           Only apply the group's own score file.
  643.  
  644.     `gnus-score-find-bnews'
  645.           Apply all score files that match, using bnews syntax.  This
  646.           is the default.  If the current group is `gnu.emacs.gnus',
  647.           for instance, `all.emacs.all.SCORE', `not.alt.all.SCORE' and
  648.           `gnu.all.SCORE' would all apply.  In short, the instances of
  649.           `all' in the score file names are translated into `.+', and
  650.           then a regexp match is done.
  651.  
  652.           This means that if you have some score entries that you want
  653.           to apply to all groups, then you put those entries in the
  654.           `all.SCORE' file.
  655.  
  656.           The score files are applied in a semi-random order, although
  657.           Gnus will try to apply the more general score files before
  658.           the more specific score files.  It does this by looking at
  659.           the number of elements in the score file names--discarding
  660.           the `all' elements.
  661.  
  662.     `gnus-score-find-hierarchical'
  663.           Apply all score files from all the parent groups.  This means
  664.           that you can't have score files like `all.SCORE', but you can
  665.           have `SCORE', `comp.SCORE' and `comp.emacs.SCORE'.
  666.  
  667.      This variable can also be a list of functions.  In that case, all
  668.      these functions will be called, and all the returned lists of
  669.      score files will be applied.  These functions can also return
  670.      lists of score alists directly.  In that case, the functions that
  671.      return these non-file score alists should probably be placed
  672.      before the "real" score file functions, to ensure that the last
  673.      score file returned is the local score file.  Phu.
  674.  
  675. `gnus-score-expiry-days'
  676.      This variable says how many days should pass before an unused
  677.      score file entry is expired.  If this variable is `nil', no score
  678.      file entries are expired.  It's 7 by default.
  679.  
  680. `gnus-update-score-entry-dates'
  681.      If this variable is non-`nil', matching score entries will have
  682.      their dates updated.  (This is how Gnus controls expiry--all
  683.      non-matching entries will become too old while matching entries
  684.      will stay fresh and young.)  However, if you set this variable to
  685.      `nil', even matching entries will grow old and will have to face
  686.      that oh-so grim reaper.
  687.  
  688. `gnus-score-after-write-file-function'
  689.      Function called with the name of the score file just written.
  690.  
  691. 
  692. File: gnus.info,  Node: Score File Format,  Next: Score File Editing,  Prev: Score Variables,  Up: Scoring
  693.  
  694. Score File Format
  695. =================
  696.  
  697.    A score file is an `emacs-lisp' file that normally contains just a
  698. single form.  Casual users are not expected to edit these files;
  699. everything can be changed from the summary buffer.
  700.  
  701.    Anyway, if you'd like to dig into it yourself, here's an example:
  702.  
  703.      (("from"
  704.        ("Lars Ingebrigtsen" -10000)
  705.        ("Per Abrahamsen")
  706.        ("larsi\\|lmi" -50000 nil R))
  707.       ("subject"
  708.        ("Ding is Badd" nil 728373))
  709.       ("xref"
  710.        ("alt.politics" -1000 728372 s))
  711.       ("lines"
  712.        (2 -100 nil <))
  713.       (mark 0)
  714.       (expunge -1000)
  715.       (mark-and-expunge -10)
  716.       (read-only nil)
  717.       (orphan -10)
  718.       (adapt t)
  719.       (files "/hom/larsi/News/gnu.SCORE")
  720.       (exclude-files "all.SCORE")
  721.       (local (gnus-newsgroup-auto-expire t)
  722.              (gnus-summary-make-false-root 'empty))
  723.       (eval (ding)))
  724.  
  725.    This example demonstrates most score file elements.  For a different
  726. approach, see *note Advanced Scoring::..
  727.  
  728.    Even though this looks much like lisp code, nothing here is actually
  729. `eval'ed.  The lisp reader is used to read this form, though, so it has
  730. to be legal syntactically, if not semantically.
  731.  
  732.    Six keys are supported by this alist:
  733.  
  734. `STRING'
  735.      If the key is a string, it is the name of the header to perform the
  736.      match on.  Scoring can only be performed on these eight headers:
  737.      `From', `Subject', `References', `Message-ID', `Xref', `Lines',
  738.      `Chars' and `Date'.  In addition to these headers, there are three
  739.      strings to tell Gnus to fetch the entire article and do the match
  740.      on larger parts of the article: `Body' will perform the match on
  741.      the body of the article, `Head' will perform the match on the head
  742.      of the article, and `All' will perform the match on the entire
  743.      article.  Note that using any of these last three keys will slow
  744.      down group entry *considerably*.  The final "header" you can score
  745.      on is `Followup'.  These score entries will result in new score
  746.      entries being added for all follow-ups to articles that matches
  747.      these score entries.
  748.  
  749.      Following this key is a arbitrary number of score entries, where
  750.      each score entry has one to four elements.
  751.        1. The first element is the "match element".  On most headers
  752.           this will be a string, but on the Lines and Chars headers,
  753.           this must be an integer.
  754.  
  755.        2. If the second element is present, it should be a number--the
  756.           "score element".  This number should be an integer in the
  757.           neginf to posinf interval.  This number is added to the score
  758.           of the article if the match is successful.  If this element
  759.           is not present, the `gnus-score-interactive-default-score'
  760.           number will be used instead.  This is 1000 by default.
  761.  
  762.        3. If the third element is present, it should be a number--the
  763.           "date element".  This date says when the last time this score
  764.           entry matched, which provides a mechanism for expiring the
  765.           score entries.  It this element is not present, the score
  766.           entry is permanent.  The date is represented by the number of
  767.           days since December 31, 1 BCE.
  768.  
  769.        4. If the fourth element is present, it should be a symbol--the
  770.           "type element".  This element specifies what function should
  771.           be used to see whether this score entry matches the article.
  772.           What match types that can be used depends on what header you
  773.           wish to perform the match on.
  774.          "From, Subject, References, Xref, Message-ID"
  775.                For most header types, there are the `r' and `R'
  776.                (regexp), as well as `s' and `S' (substring) types, and
  777.                `e' and `E' (exact match), and `w' (word match) types.
  778.                If this element is not present, Gnus will assume that
  779.                substring matching should be used.  `R', `S', and `E'
  780.                differ from the others in that the matches will be done
  781.                in a case-sensitive manner.  All these one-letter types
  782.                are really just abbreviations for the `regexp',
  783.                `string', `exact', and `word' types, which you can use
  784.                instead, if you feel like.
  785.  
  786.          "Lines, Chars"
  787.                These two headers use different match types: `<', `>',
  788.                `=', `>=' and `<='.  When matching on `Lines', be
  789.                careful because some backends (like `nndir') do not
  790.                generate `Lines' header, so every article ends up being
  791.                marked as having 0 lines.  This can lead to strange
  792.                results if you happen to lower score of the articles
  793.                with few lines.
  794.  
  795.          "Date"
  796.                For the Date header we have three kinda silly match
  797.                types: `before', `at' and `after'.  I can't really
  798.                imagine this ever being useful, but, like, it would feel
  799.                kinda silly not to provide this function.  Just in case.
  800.                You never know.  Better safe than sorry.  Once burnt,
  801.                twice shy.  Don't judge a book by its cover.  Never not
  802.                have sex on a first date.  (I have been told that at
  803.                least one person, and I quote, "found this function
  804.                indispensable", however.)
  805.  
  806.                A more useful match type is `regexp'.  With it, you can
  807.                match the date string using a regular expression.  The
  808.                date is normalized to ISO8601 compact format
  809.                first--YYYYMMDD`T'HHMMSS.  If you want to match all
  810.                articles that have been posted on April 1st in every
  811.                year, you could use `....0401.........' as a match
  812.                string, for instance.  (Note that the date is kept in
  813.                its original time zone, so this will match articles that
  814.                were posted when it was April 1st where the article was
  815.                posted from.  Time zones are such wholesome fun for the
  816.                whole family, eh?)
  817.  
  818.          "Head, Body, All"
  819.                These three match keys use the same match types as the
  820.                `From' (etc) header uses.
  821.  
  822.          "Followup"
  823.                This match key is somewhat special, in that it will
  824.                match the `From' header, and affect the score of not
  825.                only the matching articles, but also all followups to
  826.                the matching articles.  This allows you e.g. increase
  827.                the score of followups to your own articles, or decrease
  828.                the score of followups to the articles of some known
  829.                trouble-maker.  Uses the same match types as the `From'
  830.                header uses.  (Using this match key will lead to
  831.                creation of `ADAPT' files.)
  832.  
  833.          "Thread"
  834.                This match key works along the same lines as the
  835.                `Followup' match key.  If you say that you want to score
  836.                on a (sub-)thread started by an article with a
  837.                `Message-ID' X, then you add a `thread' match.  This
  838.                will add a new `thread' match for each article that has
  839.                X in its `References' header.  (These new `thread'
  840.                matches will use the `Message-ID's of these matching
  841.                articles.)  This will ensure that you can raise/lower
  842.                the score of an entire thread, even though some articles
  843.                in the thread may not have complete `References'
  844.                headers.  Note that using this may lead to
  845.                undeterministic scores of the articles in the thread.
  846.                (Using this match key will lead to creation of `ADAPT'
  847.                files.)
  848.  
  849. `mark'
  850.      The value of this entry should be a number.  Any articles with a
  851.      score lower than this number will be marked as read.
  852.  
  853. `expunge'
  854.      The value of this entry should be a number.  Any articles with a
  855.      score lower than this number will be removed from the summary
  856.      buffer.
  857.  
  858. `mark-and-expunge'
  859.      The value of this entry should be a number.  Any articles with a
  860.      score lower than this number will be marked as read and removed
  861.      from the summary buffer.
  862.  
  863. `thread-mark-and-expunge'
  864.      The value of this entry should be a number.  All articles that
  865.      belong to a thread that has a total score below this number will
  866.      be marked as read and removed from the summary buffer.
  867.      `gnus-thread-score-function' says how to compute the total score
  868.      for a thread.
  869.  
  870. `files'
  871.      The value of this entry should be any number of file names.  These
  872.      files are assumed to be score files as well, and will be loaded
  873.      the same way this one was.
  874.  
  875. `exclude-files'
  876.      The clue of this entry should be any number of files.  These files
  877.      will not be loaded, even though they would normally be so, for
  878.      some reason or other.
  879.  
  880. `eval'
  881.      The value of this entry will be `eval'el.  This element will be
  882.      ignored when handling global score files.
  883.  
  884. `read-only'
  885.      Read-only score files will not be updated or saved.  Global score
  886.      files should feature this atom (*note Global Score Files::.).
  887.  
  888. `orphan'
  889.      The value of this entry should be a number.  Articles that do not
  890.      have parents will get this number added to their scores.  Imagine
  891.      you follow some high-volume newsgroup, like `comp.lang.c'.  Most
  892.      likely you will only follow a few of the threads, also want to see
  893.      any new threads.
  894.  
  895.      You can do this with the following two score file entries:
  896.  
  897.                   (orphan -500)
  898.                   (mark-and-expunge -100)
  899.  
  900.      When you enter the group the first time, you will only see the new
  901.      threads.  You then raise the score of the threads that you find
  902.      interesting (with `I T' or `I S'), and ignore (`C y') the rest.
  903.      Next time you enter the group, you will see new articles in the
  904.      interesting threads, plus any new threads.
  905.  
  906.      I.e.--the orphan score atom is for high-volume groups where there
  907.      exist a few interesting threads which can't be found automatically
  908.      by ordinary scoring rules.
  909.  
  910. `adapt'
  911.      This entry controls the adaptive scoring.  If it is `t', the
  912.      default adaptive scoring rules will be used.  If it is `ignore', no
  913.      adaptive scoring will be performed on this group.  If it is a
  914.      list, this list will be used as the adaptive scoring rules.  If it
  915.      isn't present, or is something other than `t' or `ignore', the
  916.      default adaptive scoring rules will be used.  If you want to use
  917.      adaptive scoring on most groups, you'd set
  918.      `gnus-use-adaptive-scoring' to `t', and insert an `(adapt ignore)'
  919.      in the groups where you do not want adaptive scoring.  If you only
  920.      want adaptive scoring in a few groups, you'd set
  921.      `gnus-use-adaptive-scoring' to `nil', and insert `(adapt t)' in
  922.      the score files of the groups where you want it.
  923.  
  924. `adapt-file'
  925.      All adaptive score entries will go to the file named by this
  926.      entry.  It will also be applied when entering the group.  This
  927.      atom might be handy if you want to adapt on several groups at
  928.      once, using the same adaptive file for a number of groups.
  929.  
  930. `local'
  931.      The value of this entry should be a list of `(VAR VALUE)' pairs.
  932.      Each VAR will be made buffer-local to the current summary buffer,
  933.      and set to the value specified.  This is a convenient, if somewhat
  934.      strange, way of setting variables in some groups if you don't like
  935.      hooks much.
  936.  
  937. 
  938. File: gnus.info,  Node: Score File Editing,  Next: Adaptive Scoring,  Prev: Score File Format,  Up: Scoring
  939.  
  940. Score File Editing
  941. ==================
  942.  
  943.    You normally enter all scoring commands from the summary buffer, but
  944. you might feel the urge to edit them by hand as well, so we've supplied
  945. you with a mode for that.
  946.  
  947.    It's simply a slightly customized `emacs-lisp' mode, with these
  948. additional commands:
  949.  
  950. `C-c C-c'
  951.      Save the changes you have made and return to the summary buffer
  952.      (`gnus-score-edit-done').
  953.  
  954. `C-c C-d'
  955.      Insert the current date in numerical format
  956.      (`gnus-score-edit-insert-date').  This is really the day number, if
  957.      you were wondering.
  958.  
  959. `C-c C-p'
  960.      The adaptive score files are saved in an unformatted fashion.  If
  961.      you intend to read one of these files, you want to "pretty print"
  962.      it first.  This command (`gnus-score-pretty-print') does that for
  963.      you.
  964.  
  965.    Type `M-x gnus-score-mode' to use this mode.
  966.  
  967.    `gnus-score-menu-hook' is run in score mode buffers.
  968.  
  969.    In the summary buffer you can use commands like `V f' and `V e' to
  970. begin editing score files.
  971.  
  972. 
  973. File: gnus.info,  Node: Adaptive Scoring,  Next: Home Score File,  Prev: Score File Editing,  Up: Scoring
  974.  
  975. Adaptive Scoring
  976. ================
  977.  
  978.    If all this scoring is getting you down, Gnus has a way of making it
  979. all happen automatically--as if by magic.  Or rather, as if by
  980. artificial stupidity, to be precise.
  981.  
  982.    When you read an article, or mark an article as read, or kill an
  983. article, you leave marks behind.  On exit from the group, Gnus can sniff
  984. these marks and add score elements depending on what marks it finds.
  985. You turn on this ability by setting `gnus-use-adaptive-scoring' to `t'
  986. or `(line)'.  If you want score adaptively on separate words appearing
  987. in the subjects, you should set this variable to `(word)'.  If you want
  988. to use both adaptive methods, set this variable to `(word line)'.
  989.  
  990.    To give you complete control over the scoring process, you can
  991. customize the `gnus-default-adaptive-score-alist' variable.  For
  992. instance, it might look something like this:
  993.  
  994.      (defvar gnus-default-adaptive-score-alist
  995.        '((gnus-unread-mark)
  996.          (gnus-ticked-mark (from 4))
  997.          (gnus-dormant-mark (from 5))
  998.          (gnus-del-mark (from -4) (subject -1))
  999.          (gnus-read-mark (from 4) (subject 2))
  1000.          (gnus-expirable-mark (from -1) (subject -1))
  1001.          (gnus-killed-mark (from -1) (subject -3))
  1002.          (gnus-kill-file-mark)
  1003.          (gnus-ancient-mark)
  1004.          (gnus-low-score-mark)
  1005.          (gnus-catchup-mark (from -1) (subject -1))))
  1006.  
  1007.    As you see, each element in this alist has a mark as a key (either a
  1008. variable name or a "real" mark--a character).  Following this key is a
  1009. arbitrary number of header/score pairs.  If there are no header/score
  1010. pairs following the key, no adaptive scoring will be done on articles
  1011. that have that key as the article mark.  For instance, articles with
  1012. `gnus-unread-mark' in the example above will not get adaptive score
  1013. entries.
  1014.  
  1015.    Each article can have only one mark, so just a single of these rules
  1016. will be applied to each article.
  1017.  
  1018.    To take `gnus-del-mark' as an example--this alist says that all
  1019. articles that have that mark (i.e., are marked with `D') will have a
  1020. score entry added to lower based on the `From' header by -4, and
  1021. lowered by `Subject' by -1.  Change this to fit your prejudices.
  1022.  
  1023.    If you have marked 10 articles with the same subject with
  1024. `gnus-del-mark', the rule for that mark will be applied ten times.
  1025. That means that that subject will get a score of ten times -1, which
  1026. should be, unless I'm much mistaken, -10.
  1027.  
  1028.    If you have auto-expirable (mail) groups (*note Expiring Mail::.),
  1029. all the read articles will be marked with the `E' mark.  This'll
  1030. probably make adaptive scoring slightly impossible, so auto-expiring and
  1031. adaptive scoring doesn't really mix very well.
  1032.  
  1033.    The headers you can score on are `from', `subject', `message-id',
  1034. `references', `xref', `lines', `chars' and `date'.  In addition, you
  1035. can score on `followup', which will create an adaptive score entry that
  1036. matches on the `References' header using the `Message-ID' of the
  1037. current article, thereby matching the following thread.
  1038.  
  1039.    You can also score on `thread', which will try to score all articles
  1040. that appear in a thread.  `thread' matches uses a `Message-ID' to match
  1041. on the `References' header of the article.  If the match is made, the
  1042. `Message-ID' of the article is added to the `thread' rule.  (Think
  1043. about it.  I'd recommend two aspirins afterwards.)
  1044.  
  1045.    If you use this scheme, you should set the score file atom `mark' to
  1046. something small--like -300, perhaps, to avoid having small random
  1047. changes result in articles getting marked as read.
  1048.  
  1049.    After using adaptive scoring for a week or so, Gnus should start to
  1050. become properly trained and enhance the authors you like best, and kill
  1051. the authors you like least, without you having to say so explicitly.
  1052.  
  1053.    You can control what groups the adaptive scoring is to be performed
  1054. on by using the score files (*note Score File Format::.).  This will
  1055. also let you use different rules in different groups.
  1056.  
  1057.    The adaptive score entries will be put into a file where the name is
  1058. the group name with `gnus-adaptive-file-suffix' appended.  The default
  1059. is `ADAPT'.
  1060.  
  1061.    When doing adaptive scoring, substring or fuzzy matching would
  1062. probably give you the best results in most cases.  However, if the
  1063. header one matches is short, the possibility for false positives is
  1064. great, so if the length of the match is less than
  1065. `gnus-score-exact-adapt-limit', exact matching will be used.  If this
  1066. variable is `nil', exact matching will always be used to avoid this
  1067. problem.
  1068.  
  1069.    As mentioned above, you can adapt either on individual words or
  1070. entire headers.  If you adapt on words, the
  1071. `gnus-default-adaptive-word-score-alist' variable says what score each
  1072. instance of a word should add given a mark.
  1073.  
  1074.      (setq gnus-default-adaptive-word-score-alist
  1075.            `((,gnus-read-mark . 30)
  1076.              (,gnus-catchup-mark . -10)
  1077.              (,gnus-killed-mark . -20)
  1078.              (,gnus-del-mark . -15)))
  1079.  
  1080.    This is the default value.  If you have adaption on words enabled,
  1081. every word that appears in subjects of articles marked with
  1082. `gnus-read-mark' will result in a score rule that increase the score
  1083. with 30 points.
  1084.  
  1085.    Words that appear in the `gnus-default-ignored-adaptive-words' list
  1086. will be ignored.  If you wish to add more words to be ignored, use the
  1087. `gnus-ignored-adaptive-words' list instead.
  1088.  
  1089.    When the scoring is done, `gnus-adaptive-word-syntax-table' is the
  1090. syntax table in effect.  It is similar to the standard syntax table, but
  1091. it considers numbers to be non-word-constituent characters.
  1092.  
  1093.    After using this scheme for a while, it might be nice to write a
  1094. `gnus-psychoanalyze-user' command to go through the rules and see what
  1095. words you like and what words you don't like.  Or perhaps not.
  1096.  
  1097.    Note that the adaptive word scoring thing is highly experimental and
  1098. is likely to change in the future.  Initial impressions seem to indicate
  1099. that it's totally useless as it stands.  Some more work (involving more
  1100. rigorous statistical methods) will have to be done to make this useful.
  1101.  
  1102. 
  1103. File: gnus.info,  Node: Home Score File,  Next: Followups To Yourself,  Prev: Adaptive Scoring,  Up: Scoring
  1104.  
  1105. Home Score File
  1106. ===============
  1107.  
  1108.    The score file where new score file entries will go is called the
  1109. "home score file".  This is normally (and by default) the score file
  1110. for the group itself.  For instance, the home score file for
  1111. `gnu.emacs.gnus' is `gnu.emacs.gnus.SCORE'.
  1112.  
  1113.    However, this may not be what you want.  It is often convenient to
  1114. share a common home score file among many groups--all `emacs' groups
  1115. could perhaps use the same home score file.
  1116.  
  1117.    The variable that controls this is `gnus-home-score-file'.  It can
  1118. be:
  1119.  
  1120.   1. A string.  Then this file will be used as the home score file for
  1121.      all groups.
  1122.  
  1123.   2. A function. The result of this function will be used as the home
  1124.      score file.  The function will be called with the name of the
  1125.      group as the parameter.
  1126.  
  1127.   3. A list.  The elements in this list can be:
  1128.  
  1129.        1. (REGEXP FILE-NAME).  If the REGEXP matches the group name,
  1130.           the FILE-NAME will will be used as the home score file.
  1131.  
  1132.        2. A function. If the function returns non-nil, the result will
  1133.           be used as the home score file.
  1134.  
  1135.        3. A string.  Use the string as the home score file.
  1136.  
  1137.      The list will be traversed from the beginning towards the end
  1138.      looking for matches.
  1139.  
  1140.  
  1141.    So, if you want to use just a single score file, you could say:
  1142.  
  1143.      (setq gnus-home-score-file
  1144.            "my-total-score-file.SCORE")
  1145.  
  1146.    If you want to use `gnu.SCORE' for all `gnu' groups and `rec.SCORE'
  1147. for all `rec' groups (and so on), you can say:
  1148.  
  1149.      (setq gnus-home-score-file
  1150.            'gnus-hierarchial-home-score-file)
  1151.  
  1152.    This is a ready-made function provided for your convenience.
  1153.  
  1154.    If you want to have one score file for the `emacs' groups and
  1155. another for the `comp' groups, while letting all other groups use their
  1156. own home score files:
  1157.  
  1158.      (setq gnus-home-score-file
  1159.            ;; All groups that match the regexp "\\.emacs"
  1160.            '("\\.emacs" "emacs.SCORE")
  1161.            ;; All the comp groups in one score file
  1162.             ("^comp" "comp.SCORE"))
  1163.  
  1164.    `gnus-home-adapt-file' works exactly the same way as
  1165. `gnus-home-score-file', but says what the home adaptive score file is
  1166. instead.  All new adaptive file entries will go into the file specified
  1167. by this variable, and the same syntax is allowed.
  1168.  
  1169.    In addition to using `gnus-home-score-file' and
  1170. `gnus-home-adapt-file', you can also use group parameters (*note Group
  1171. Parameters::.) and topic parameters (*note Topic Parameters::.) to
  1172. achieve much the same.  Group and topic parameters take precedence over
  1173. this variable.
  1174.  
  1175. 
  1176. File: gnus.info,  Node: Followups To Yourself,  Next: Scoring Tips,  Prev: Home Score File,  Up: Scoring
  1177.  
  1178. Followups To Yourself
  1179. =====================
  1180.  
  1181.    Gnus offers two commands for picking out the `Message-ID' header in
  1182. the current buffer.  Gnus will then add a score rule that scores using
  1183. this `Message-ID' on the `References' header of other articles.  This
  1184. will, in effect, increase the score of all articles that respond to the
  1185. article in the current buffer.  Quite useful if you want to easily note
  1186. when people answer what you've said.
  1187.  
  1188. `gnus-score-followup-article'
  1189.      This will add a score to articles that directly follow up your own
  1190.      article.
  1191.  
  1192. `gnus-score-followup-thread'
  1193.      This will add a score to all articles that appear in a thread
  1194.      "below" your own article.
  1195.  
  1196.    These two functions are both primarily meant to be used in hooks like
  1197. `message-sent-hook'.
  1198.  
  1199.    If you look closely at your own `Message-ID', you'll notice that the
  1200. first two or three characters are always the same.  Here's two of mine:
  1201.  
  1202.      <x6u3u47icf.fsf@eyesore.no>
  1203.      <x6sp9o7ibw.fsf@eyesore.no>
  1204.  
  1205.    So "my" ident on this machine is `x6'.  This can be exploited--the
  1206. following rule will raise the score on all followups to myself:
  1207.  
  1208.      ("references"
  1209.       ("<x6[0-9a-z]+\\.fsf\\(_-_\\)?@.*eyesore.no>"
  1210.        1000 nil r))
  1211.  
  1212.    Whether it's the first two or first three characters that are "yours"
  1213. is system-dependent.
  1214.  
  1215. 
  1216. File: gnus.info,  Node: Scoring Tips,  Next: Reverse Scoring,  Prev: Followups To Yourself,  Up: Scoring
  1217.  
  1218. Scoring Tips
  1219. ============
  1220.  
  1221. "Crossposts"
  1222.      If you want to lower the score of crossposts, the line to match on
  1223.      is the `Xref' header.
  1224.           ("xref" (" talk.politics.misc:" -1000))
  1225.  
  1226. "Multiple crossposts"
  1227.      If you want to lower the score of articles that have been
  1228.      crossposted to more than, say, 3 groups:
  1229.           ("xref" ("[^:\n]+:[0-9]+ +[^:\n]+:[0-9]+ +[^:\n]+:[0-9]+" -1000 nil r))
  1230.  
  1231. "Matching on the body"
  1232.      This is generally not a very good idea--it takes a very long time.
  1233.      Gnus actually has to fetch each individual article from the
  1234.      server.  But you might want to anyway, I guess.  Even though there
  1235.      are three match keys (`Head', `Body' and `All'), you should choose
  1236.      one and stick with it in each score file.  If you use any two,
  1237.      each article will be fetched *twice*.  If you want to match a bit
  1238.      on the `Head' and a bit on the `Body', just use `All' for all the
  1239.      matches.
  1240.  
  1241. "Marking as read"
  1242.      You will probably want to mark articles that has a score below a
  1243.      certain number as read.  This is most easily achieved by putting
  1244.      the following in your `all.SCORE' file:
  1245.           ((mark -100))
  1246.      You may also consider doing something similar with `expunge'.
  1247.  
  1248. "Negated character classes"
  1249.      If you say stuff like `[^abcd]*', you may get unexpected results.
  1250.      That will match newlines, which might lead to, well, The Unknown.
  1251.      Say `[^abcd\n]*' instead.
  1252.  
  1253. 
  1254. File: gnus.info,  Node: Reverse Scoring,  Next: Global Score Files,  Prev: Scoring Tips,  Up: Scoring
  1255.  
  1256. Reverse Scoring
  1257. ===============
  1258.  
  1259.    If you want to keep just articles that have `Sex with Emacs' in the
  1260. subject header, and expunge all other articles, you could put something
  1261. like this in your score file:
  1262.  
  1263.      (("subject"
  1264.        ("Sex with Emacs" 2))
  1265.       (mark 1)
  1266.       (expunge 1))
  1267.  
  1268.    So, you raise all articles that match `Sex with Emacs' and mark the
  1269. rest as read, and expunge them to boot.
  1270.  
  1271.